home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / dist-packages / snack.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-12  |  36.8 KB  |  1,030 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''
  5. This module provides the NEWT Windowing toolkit API for Python
  6. This is a lightweight text-mode windowing library, based on slang.
  7.  
  8. Classes:
  9.  
  10.  - Widget  
  11.  - Button  
  12.  - CompactButton
  13.  - Checkbox
  14.  - SingleRadioButton
  15.  - Listbox
  16.  - Textbox
  17.  - TextboxReflowed
  18.  - Label
  19.  - Scale
  20.  - Entry
  21.  - Form
  22.  - Grid
  23.  - SnackScreen
  24.  - RadioGroup
  25.  - RadioBar
  26.  - ButtonBar
  27.  - GridFormHelp
  28.  - GridForm
  29.  - CheckboxTree
  30.  - Clistbox
  31.  
  32. Functions:
  33.  
  34.  - ListboxChoiceWindow
  35.  - ButtonChoiceWindow
  36.  - EntryWindow
  37. '''
  38. import _snack
  39. import types
  40. import string
  41. from _snack import FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE, FD_READ, FD_WRITE, FD_EXCEPT
  42. LEFT = (-1, 0)
  43. DOWN = (-1, -1)
  44. CENTER = (0, 0)
  45. UP = (1, 1)
  46. RIGHT = (1, 0)
  47. snackArgs = {
  48.     'append': -1 }
  49.  
  50. class Widget:
  51.     '''Base class for NEWT toolkit
  52.  
  53.     methods:
  54.  
  55.      - Widget(self)
  56.      - setCallback(self, obj, data = None) : 
  57.           The callback for when object activated.
  58.           data is passed to obj.
  59.     '''
  60.     
  61.     def setCallback(self, obj, data = None):
  62.         if data:
  63.             self.w.setCallback(obj, data)
  64.         else:
  65.             self.w.setCallback(obj)
  66.  
  67.     
  68.     def __init__(self):
  69.         self.w = None
  70.  
  71.  
  72.  
  73. class Button(Widget):
  74.     '''Basic button class, takes button text as parameter
  75.  
  76.     method:
  77.  
  78.      - Button(self, text): returns a button
  79.     '''
  80.     
  81.     def __init__(self, text):
  82.         self.w = _snack.button(text)
  83.  
  84.  
  85.  
  86. class CompactButton(Widget):
  87.     '''Compact Button class (less frilly button decoration).
  88.  
  89.     methods:
  90.  
  91.      - CompactButton(self,text) : create button, with text.
  92.     '''
  93.     
  94.     def __init__(self, text):
  95.         self.w = _snack.compactbutton(text)
  96.  
  97.  
  98.  
  99. class Checkbox(Widget):
  100.     '''A checkbox.
  101.  
  102.     methods:
  103.     
  104.       - Checkbox(self, text, isOn = 0) : text, and boolean as to default value
  105.       - setValue(self)                 : set value
  106.       - value(self, value)             : return checkbox value
  107.       - selected(self)                 : returns boolean
  108.       - setFlags(self, flag, sense)    : set flags
  109.  
  110.       flags:  FLAG_DISABLED, FLAGS_SET, FLAGS_RESET
  111.     '''
  112.     
  113.     def value(self):
  114.         return self.w.checkboxValue
  115.  
  116.     
  117.     def selected(self):
  118.         return self.w.checkboxValue != 0
  119.  
  120.     
  121.     def setFlags(self, flag, sense):
  122.         return self.w.checkboxSetFlags(flag, sense)
  123.  
  124.     
  125.     def setValue(self, value):
  126.         return self.w.checkboxSetValue(value)
  127.  
  128.     
  129.     def __init__(self, text, isOn = 0):
  130.         self.w = _snack.checkbox(text, isOn)
  131.  
  132.  
  133.  
  134. class SingleRadioButton(Widget):
  135.     '''Single Radio Button.
  136.  
  137.     methods:
  138.     
  139.      -  SingleRadioButton(text, group, isOn = 0)  : create button
  140.      -  selected(self)                            : returns bool, whether or not is selected.
  141.     '''
  142.     
  143.     def selected(self):
  144.         return self.w.key == self.w.radioValue
  145.  
  146.     
  147.     def __init__(self, text, group, isOn = 0):
  148.         if group:
  149.             self.w = _snack.radiobutton(text, group.w, isOn)
  150.         else:
  151.             self.w = _snack.radiobutton(text, None, isOn)
  152.  
  153.  
  154.  
  155. class Listbox(Widget):
  156.     """Listbox class.
  157.  
  158.     methods:
  159.  
  160.      - Listbox(self,height, scroll = 0l returnExit = 0, width = 0, showCursor = 0)
  161.      - insert(self, text, item, before) : insert element; before = key to item to insert before, or None.
  162.      - delete(self, item)               : delete item from list.
  163.      - replace(self, text,item)         : Replace a given item's text
  164.      - current(self)                    : returns currently selected item
  165.      - setCurrent(self,i tem)           : select current.
  166.      - clear(self)                      : clear listbox
  167.     """
  168.     
  169.     def append(self, text, item):
  170.         key = self.w.listboxAddItem(text)
  171.         self.key2item[key] = item
  172.         self.item2key[item] = key
  173.  
  174.     
  175.     def insert(self, text, item, before):
  176.         if not before:
  177.             key = self.w.listboxInsertItem(text, 0)
  178.         else:
  179.             key = self.w.listboxInsertItem(text, self.item2key[before])
  180.         self.key2item[key] = item
  181.         self.item2key[item] = key
  182.  
  183.     
  184.     def delete(self, item):
  185.         self.w.listboxDeleteItem(self.item2key[item])
  186.         del self.key2item[self.item2key[item]]
  187.         del self.item2key[item]
  188.  
  189.     
  190.     def replace(self, text, item):
  191.         key = self.w.listboxInsertItem(text, self.item2key[item])
  192.         self.w.listboxDeleteItem(self.item2key[item])
  193.         del self.key2item[self.item2key[item]]
  194.         self.item2key[item] = key
  195.         self.key2item[key] = item
  196.  
  197.     
  198.     def current(self):
  199.         return self.key2item[self.w.listboxGetCurrent()]
  200.  
  201.     
  202.     def setCurrent(self, item):
  203.         self.w.listboxSetCurrent(self.item2key[item])
  204.  
  205.     
  206.     def clear(self):
  207.         self.key2item = { }
  208.         self.item2key = { }
  209.         self.w.listboxClear()
  210.  
  211.     
  212.     def __init__(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0):
  213.         self.w = _snack.listbox(height, scroll, returnExit, showCursor)
  214.         self.key2item = { }
  215.         self.item2key = { }
  216.         if width:
  217.             self.w.listboxSetWidth(width)
  218.         
  219.  
  220.  
  221.  
  222. class Textbox(Widget):
  223.     '''Textbox, container for text.
  224.  
  225.     methods:
  226.  
  227.      - Textbox(self, width, height, scroll = 0, wrap = 0): scroll, wrap are flags
  228.                                    include scroll bars, or text wrap.
  229.      - setText(text) : set text.
  230.     '''
  231.     
  232.     def setText(self, text):
  233.         self.w.textboxText(text)
  234.  
  235.     
  236.     def __init__(self, width, height, text, scroll = 0, wrap = 0):
  237.         self.w = _snack.textbox(width, height, text, scroll, wrap)
  238.  
  239.  
  240.  
  241. class TextboxReflowed(Textbox):
  242.     
  243.     def __init__(self, width, text, flexDown = 5, flexUp = 10, maxHeight = -1):
  244.         (newtext, width, height) = reflow(text, width, flexDown, flexUp)
  245.         if maxHeight != -1 and height > maxHeight:
  246.             Textbox.__init__(self, width, maxHeight, newtext, 1)
  247.         else:
  248.             Textbox.__init__(self, width, height, newtext, 0)
  249.  
  250.  
  251.  
  252. class Label(Widget):
  253.     '''A Label (simple text).
  254.  
  255.     methods:
  256.  
  257.      - Label(self,text)   : create label
  258.      - setText(self,text) : change text.
  259.     '''
  260.     
  261.     def setText(self, text):
  262.         self.w.labelText(text)
  263.  
  264.     
  265.     def __init__(self, text):
  266.         self.w = _snack.label(text)
  267.  
  268.  
  269.  
  270. class Scale(Widget):
  271.     '''A Scale (progress bar).
  272.  
  273.     methods:
  274.  
  275.      - Scale(self,width, total) : create scale; width: size on screen, fullamount: integer.
  276.      - set(self,amount)         : set amount to integer.
  277.     '''
  278.     
  279.     def set(self, amount):
  280.         self.w.scaleSet(amount)
  281.  
  282.     
  283.     def __init__(self, width, total):
  284.         self.w = _snack.scale(width, total)
  285.  
  286.  
  287.  
  288. class Entry(Widget):
  289.     '''Entry widget.
  290.  
  291.     methods:
  292.  
  293.      - Entry(self, width, text = "", hidden = 0, password = 0, scroll = 1, returnExit = 0)
  294.           constructor. hidden doesn\'t show text, password stars it out,
  295.           scroll includes scroll bars;
  296.           if returnExit is set, return from Form when exiting this element, else
  297.            proceed to next entry widget.
  298.      - value(self): return value.
  299.      - set(text) : set the text
  300.      - setFlags (flag, sense) : flags can be FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE
  301.     '''
  302.     
  303.     def value(self):
  304.         return self.w.entryValue
  305.  
  306.     
  307.     def set(self, text):
  308.         return self.w.entrySetValue(text)
  309.  
  310.     
  311.     def setFlags(self, flag, sense):
  312.         return self.w.entrySetFlags(flag, sense)
  313.  
  314.     
  315.     def __init__(self, width, text = '', hidden = 0, password = 0, scroll = 1, returnExit = 0):
  316.         self.w = _snack.entry(width, text, hidden, password, scroll, returnExit)
  317.  
  318.  
  319. hotkeys = {
  320.     'F1': _snack.KEY_F1,
  321.     'F2': _snack.KEY_F2,
  322.     'F3': _snack.KEY_F3,
  323.     'F4': _snack.KEY_F4,
  324.     'F5': _snack.KEY_F5,
  325.     'F6': _snack.KEY_F6,
  326.     'F7': _snack.KEY_F7,
  327.     'F8': _snack.KEY_F8,
  328.     'F9': _snack.KEY_F9,
  329.     'F10': _snack.KEY_F10,
  330.     'F11': _snack.KEY_F11,
  331.     'F12': _snack.KEY_F12,
  332.     'ESC': _snack.KEY_ESC,
  333.     ' ': ord(' ') }
  334. for n in hotkeys.keys():
  335.     hotkeys[hotkeys[n]] = n
  336.  
  337.  
  338. class Form:
  339.     ''' Base Form class, from which Grid, etc. inherit
  340.  
  341.     methods:
  342.  
  343.      - Form(self, helpArg = None) : constructor. 
  344.      - addHotKey(self, keyname) : keynames of form "F1" through "F12", "ESC"
  345.      - add(self, widget) : Add a widget
  346.      - run(self): run a  form, expecting input
  347.      - draw(self): draw form.
  348.      - setTimer(self, timer) : add a timer
  349.      - watchFile(self, file, flags) : watch a named file
  350.      - setCurrent (self, co): Set a given widget as the current focus
  351.     '''
  352.     
  353.     def addHotKey(self, keyname):
  354.         self.w.addhotkey(hotkeys[keyname])
  355.  
  356.     
  357.     def add(self, widget):
  358.         if widget.__dict__.has_key('hotkeys'):
  359.             for key in widget.hotkeys.keys():
  360.                 self.addHotKey(key)
  361.             
  362.         
  363.         if widget.__dict__.has_key('gridmembers'):
  364.             for w in widget.gridmembers:
  365.                 self.add(w)
  366.             
  367.         elif widget.__dict__.has_key('w'):
  368.             self.trans[widget.w.key] = widget
  369.             return self.w.add(widget.w)
  370.  
  371.     
  372.     def run(self):
  373.         (what, which) = self.w.run()
  374.         if what == _snack.FORM_EXIT_WIDGET:
  375.             return self.trans[which]
  376.         if what == _snack.FORM_EXIT_TIMER:
  377.             return 'TIMER'
  378.         if what == _snack.FORM_EXIT_FDREADY:
  379.             return self.filemap[which]
  380.         return hotkeys[which]
  381.  
  382.     
  383.     def draw(self):
  384.         self.w.draw()
  385.  
  386.     
  387.     def __init__(self, helpArg = None):
  388.         self.trans = { }
  389.         self.filemap = { }
  390.         self.w = _snack.form(helpArg)
  391.         self.helpArg = helpArg
  392.  
  393.     
  394.     def setCurrent(self, co):
  395.         self.w.setcurrent(co.w)
  396.  
  397.     
  398.     def setTimer(self, timer):
  399.         self.w.settimer(timer)
  400.  
  401.     
  402.     def watchFile(self, file, flags):
  403.         self.filemap[file.fileno()] = file
  404.         self.w.watchfd(file.fileno(), flags)
  405.  
  406.  
  407.  
  408. class Grid:
  409.     """Grid class.
  410.  
  411.     methods:
  412.  
  413.      - place(self,x,y): Return what is placed at (x,y)
  414.      - setField(self, what, col, row, padding = (0, 0, 0, 0),
  415.                 anchorLeft = 0, anchorTop = 0, anchorRight = 0,
  416.                 anchorBottom = 0, growx = 0, growy = 0):
  417.                 used to add widget 'what' to grid.
  418.      - Grid(self, *args): eg. g = Grid(2,3) for 2x3 grid
  419.     """
  420.     
  421.     def place(self, x, y):
  422.         return self.g.place(x, y)
  423.  
  424.     
  425.     def setField(self, what, col, row, padding = (0, 0, 0, 0), anchorLeft = 0, anchorTop = 0, anchorRight = 0, anchorBottom = 0, growx = 0, growy = 0):
  426.         self.gridmembers.append(what)
  427.         anchorFlags = 0
  428.         if anchorLeft:
  429.             anchorFlags = _snack.ANCHOR_LEFT
  430.         elif anchorRight:
  431.             anchorFlags = _snack.ANCHOR_RIGHT
  432.         
  433.         if anchorTop:
  434.             anchorFlags = anchorFlags | _snack.ANCHOR_TOP
  435.         elif anchorBottom:
  436.             anchorFlags = anchorFlags | _snack.ANCHOR_BOTTOM
  437.         
  438.         gridFlags = 0
  439.         if growx:
  440.             gridFlags = _snack.GRID_GROWX
  441.         
  442.         if growy:
  443.             gridFlags = gridFlags | _snack.GRID_GROWY
  444.         
  445.         if what.__dict__.has_key('g'):
  446.             return self.g.setfield(col, row, what.g, padding, anchorFlags, gridFlags)
  447.         return self.g.setfield(col, row, what.w, padding, anchorFlags)
  448.  
  449.     
  450.     def __init__(self, *args):
  451.         self.g = apply(_snack.grid, args)
  452.         self.gridmembers = []
  453.  
  454.  
  455.  
  456. class SnackScreen:
  457.     '''A Screen;
  458.  
  459.     methods:
  460.  
  461.     - Screen(self) : constructor
  462.     - finish(self)
  463.     - resume(self)
  464.     - suspend(self)
  465.     - doHelpCallback(self,arg) call callback with arg
  466.     - helpCallback(self,cb): Set help callback
  467.     - suspendcallback(self,cb, data=None) : set callback. data=data to pass to cb.
  468.     - openWindow(self,left, top, width, height, title): Open a window.
  469.     - pushHelpLine(self,text): put help line on screen. Returns current help line if text=None
  470.     '''
  471.     
  472.     def __init__(self):
  473.         _snack.init()
  474.         (self.width, self.height) = _snack.size()
  475.         self.pushHelpLine(None)
  476.  
  477.     
  478.     def finish(self):
  479.         return _snack.finish()
  480.  
  481.     
  482.     def resume(self):
  483.         _snack.resume()
  484.  
  485.     
  486.     def suspend(self):
  487.         _snack.suspend()
  488.  
  489.     
  490.     def doHelpCallback(self, arg):
  491.         self.helpCb(self, arg)
  492.  
  493.     
  494.     def helpCallback(self, cb):
  495.         self.helpCb = cb
  496.         return _snack.helpcallback(self.doHelpCallback)
  497.  
  498.     
  499.     def suspendCallback(self, cb, data = None):
  500.         if data:
  501.             return _snack.suspendcallback(cb, data)
  502.         return _snack.suspendcallback(cb)
  503.  
  504.     
  505.     def openWindow(self, left, top, width, height, title):
  506.         return _snack.openwindow(left, top, width, height, title)
  507.  
  508.     
  509.     def pushHelpLine(self, text):
  510.         if not text:
  511.             return _snack.pushhelpline('*default*')
  512.         return _snack.pushhelpline(text)
  513.  
  514.     
  515.     def popHelpLine(self):
  516.         return _snack.pophelpline()
  517.  
  518.     
  519.     def drawRootText(self, left, top, text):
  520.         return _snack.drawroottext(left, top, text)
  521.  
  522.     
  523.     def centeredWindow(self, width, height, title):
  524.         return _snack.centeredwindow(width, height, title)
  525.  
  526.     
  527.     def gridWrappedWindow(self, grid, title, x = None, y = None):
  528.         if x and y:
  529.             return _snack.gridwrappedwindow(grid.g, title, x, y)
  530.         return _snack.gridwrappedwindow(grid.g, title)
  531.  
  532.     
  533.     def popWindow(self):
  534.         return _snack.popwindow()
  535.  
  536.     
  537.     def refresh(self):
  538.         return _snack.refresh()
  539.  
  540.  
  541.  
  542. def reflow(text, width, flexDown = 5, flexUp = 5):
  543.     ''' returns a tuple of the wrapped text, the actual width, and the actual height
  544.     '''
  545.     return _snack.reflow(text, width, flexDown, flexUp)
  546.  
  547.  
  548. class RadioGroup(Widget):
  549.     ''' Combo widget: Group of Radio buttons
  550.  
  551.     methods:
  552.  
  553.      - RadioGroup(self): constructor.
  554.      - add(self,title, value, default = None): add a button. Returns button.
  555.      - getSelection(self) : returns value of selected button | None    
  556.     '''
  557.     
  558.     def __init__(self):
  559.         self.prev = None
  560.         self.buttonlist = []
  561.  
  562.     
  563.     def add(self, title, value, default = None):
  564.         if not (self.prev) and default == None:
  565.             default = 1
  566.         
  567.         b = SingleRadioButton(title, self.prev, default)
  568.         self.prev = b
  569.         self.buttonlist.append((b, value))
  570.         return b
  571.  
  572.     
  573.     def getSelection(self):
  574.         for b, value in self.buttonlist:
  575.             if b.selected():
  576.                 return value
  577.         
  578.  
  579.  
  580.  
  581. class RadioBar(Grid):
  582.     ''' Bar of Radio buttons, based on Grid.
  583.  
  584.     methods:
  585.  
  586.     - RadioBar(self, screen, buttonlist) : constructor.
  587.     - getSelection(self): return value of selected button 
  588.     '''
  589.     
  590.     def __init__(self, screen, buttonlist):
  591.         self.list = []
  592.         self.item = 0
  593.         self.group = RadioGroup()
  594.         Grid.__init__(self, 1, len(buttonlist))
  595.         for title, value, default in buttonlist:
  596.             b = self.group.add(title, value, default)
  597.             self.list.append((b, value))
  598.             self.setField(b, 0, self.item, anchorLeft = 1)
  599.             self.item = self.item + 1
  600.         
  601.  
  602.     
  603.     def getSelection(self):
  604.         return self.group.getSelection()
  605.  
  606.  
  607.  
  608. class ButtonBar(Grid):
  609.     ''' Bar of buttons, based on grid.
  610.  
  611.     methods:
  612.  
  613.      - ButtonBar(screen, buttonlist,buttonlist, compact = 0):
  614.      - buttonPressed(self, result):  Takes the widget returned by Form.run and looks to see
  615.                      if it was one of the widgets in the ButtonBar.
  616.     '''
  617.     
  618.     def __init__(self, screen, buttonlist, compact = 0):
  619.         self.list = []
  620.         self.hotkeys = { }
  621.         self.item = 0
  622.         Grid.__init__(self, len(buttonlist), 1)
  623.         for blist in buttonlist:
  624.             if type(blist) == types.StringType:
  625.                 title = blist
  626.                 value = string.lower(blist)
  627.             elif len(blist) == 2:
  628.                 (title, value) = blist
  629.             else:
  630.                 (title, value, hotkey) = blist
  631.                 self.hotkeys[hotkey] = value
  632.             if compact:
  633.                 b = CompactButton(title)
  634.             else:
  635.                 b = Button(title)
  636.             self.list.append((b, value))
  637.             self.setField(b, self.item, 0, (1, 0, 1, 0))
  638.             self.item = self.item + 1
  639.         
  640.  
  641.     
  642.     def buttonPressed(self, result):
  643.         if self.hotkeys.has_key(result):
  644.             return self.hotkeys[result]
  645.         for button, value in self.list:
  646.             if result == button:
  647.                 return value
  648.         
  649.  
  650.  
  651.  
  652. class GridFormHelp(Grid):
  653.     ''' Subclass of Grid, for the help form text.
  654.  
  655.     methods:
  656.  
  657.      - GridFormHelp(self, screen, title, help, *args) :
  658.      - add (self, widget, col, row, padding = (0, 0, 0, 0),
  659.             anchorLeft = 0, anchorTop = 0, anchorRight = 0,
  660.             anchorBottom = 0, growx = 0, growy = 0):
  661.      - runOnce(self, x = None, y = None):  pop up the help window
  662.      - addHotKey(self, keyname):
  663.      - setTimer(self, keyname):
  664.      - create(self, x = None, y = None):
  665.      - run(self, x = None, y = None):
  666.      - draw(self):
  667.      - runPopup(self):
  668.      - setCurrent (self, co):
  669.     '''
  670.     
  671.     def __init__(self, screen, title, help, *args):
  672.         self.screen = screen
  673.         self.title = title
  674.         self.form = Form(help)
  675.         self.childList = []
  676.         self.form_created = 0
  677.         args = list(args)
  678.         args[:0] = [
  679.             self]
  680.         apply(Grid.__init__, tuple(args))
  681.  
  682.     
  683.     def add(self, widget, col, row, padding = (0, 0, 0, 0), anchorLeft = 0, anchorTop = 0, anchorRight = 0, anchorBottom = 0, growx = 0, growy = 0):
  684.         self.setField(widget, col, row, padding, anchorLeft, anchorTop, anchorRight, anchorBottom, growx, growy)
  685.         self.childList.append(widget)
  686.  
  687.     
  688.     def runOnce(self, x = None, y = None):
  689.         result = self.run(x, y)
  690.         self.screen.popWindow()
  691.         return result
  692.  
  693.     
  694.     def addHotKey(self, keyname):
  695.         self.form.addHotKey(keyname)
  696.  
  697.     
  698.     def setTimer(self, keyname):
  699.         self.form.setTimer(keyname)
  700.  
  701.     
  702.     def create(self, x = None, y = None):
  703.         if not self.form_created:
  704.             self.place(1, 1)
  705.             for child in self.childList:
  706.                 self.form.add(child)
  707.             
  708.             self.screen.gridWrappedWindow(self, self.title, x, y)
  709.             self.form_created = 1
  710.         
  711.  
  712.     
  713.     def run(self, x = None, y = None):
  714.         self.create(x, y)
  715.         return self.form.run()
  716.  
  717.     
  718.     def draw(self):
  719.         self.create()
  720.         return self.form.draw()
  721.  
  722.     
  723.     def runPopup(self):
  724.         self.create()
  725.         self.screen.gridWrappedWindow(self, self.title)
  726.         result = self.form.run()
  727.         self.screen.popWindow()
  728.         return result
  729.  
  730.     
  731.     def setCurrent(self, co):
  732.         self.form.setCurrent(co)
  733.  
  734.  
  735.  
  736. class GridForm(GridFormHelp):
  737.     ''' GridForm class (extends GridFormHelp):
  738.  
  739.     methods:
  740.  
  741.      - GridForm(self, screen, title, *args):
  742.     '''
  743.     
  744.     def __init__(self, screen, title, *args):
  745.         myargs = (self, screen, title, None) + args
  746.         apply(GridFormHelp.__init__, myargs)
  747.  
  748.  
  749.  
  750. class CheckboxTree(Widget):
  751.     ''' CheckboxTree combo widget,
  752.  
  753.     methods:
  754.  
  755.      - CheckboxTree(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0)
  756.                     constructor.
  757.      - append(self, text, item = None, selected = 0):
  758.      - addItem(self, text, path, item = None, selected = 0):
  759.      - getCurrent(self):
  760.      - getSelection(self):
  761.      - setEntry(self, item, text):
  762.      - setCurrent(self, item):
  763.      - setEntryValue(self, item, selected = 1):
  764.      - getEntryValue(self, item):
  765.     '''
  766.     
  767.     def append(self, text, item = None, selected = 0):
  768.         self.addItem(text, (snackArgs['append'],), item, selected)
  769.  
  770.     
  771.     def addItem(self, text, path, item = None, selected = 0):
  772.         if item is None:
  773.             item = text
  774.         
  775.         key = self.w.checkboxtreeAddItem(text, path, selected)
  776.         self.key2item[key] = item
  777.         self.item2key[item] = key
  778.  
  779.     
  780.     def getCurrent(self):
  781.         curr = self.w.checkboxtreeGetCurrent()
  782.         return self.key2item[curr]
  783.  
  784.     
  785.     def __init__(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0):
  786.         self.w = _snack.checkboxtree(height, scroll, hide_checkbox, unselectable)
  787.         self.key2item = { }
  788.         self.item2key = { }
  789.         if width:
  790.             self.w.checkboxtreeSetWidth(width)
  791.         
  792.  
  793.     
  794.     def getSelection(self):
  795.         selection = []
  796.         list = self.w.checkboxtreeGetSelection()
  797.         for key in list:
  798.             selection.append(self.key2item[key])
  799.         
  800.         return selection
  801.  
  802.     
  803.     def setEntry(self, item, text):
  804.         self.w.checkboxtreeSetEntry(self.item2key[item], text)
  805.  
  806.     
  807.     def setCurrent(self, item):
  808.         self.w.checkboxtreeSetCurrent(self.item2key[item])
  809.  
  810.     
  811.     def setEntryValue(self, item, selected = 1):
  812.         self.w.checkboxtreeSetEntryValue(self.item2key[item], selected)
  813.  
  814.     
  815.     def getEntryValue(self, item):
  816.         return self.w.checkboxtreeGetEntryValue(self.item2key[item])
  817.  
  818.  
  819.  
  820. def ListboxChoiceWindow(screen, title, text, items, buttons = ('Ok', 'Cancel'), width = 40, scroll = 0, height = -1, default = None, help = None):
  821.     """
  822.     - ListboxChoiceWindow(screen, title, text, items, 
  823.             buttons = ('Ok', 'Cancel'), 
  824.             width = 40, scroll = 0, height = -1, default = None,
  825.             help = None):
  826.     """
  827.     if height == -1:
  828.         height = len(items)
  829.     
  830.     bb = ButtonBar(screen, buttons)
  831.     t = TextboxReflowed(width, text)
  832.     l = Listbox(height, scroll = scroll, returnExit = 1)
  833.     count = 0
  834.     for item in items:
  835.         if type(item) == types.TupleType:
  836.             (text, key) = item
  837.         else:
  838.             text = item
  839.             key = count
  840.         if default == count:
  841.             default = key
  842.         elif default == item:
  843.             default = key
  844.         
  845.         l.append(text, key)
  846.         count = count + 1
  847.     
  848.     if default != None:
  849.         l.setCurrent(default)
  850.     
  851.     g = GridFormHelp(screen, title, help, 1, 3)
  852.     g.add(t, 0, 0)
  853.     g.add(l, 0, 1, padding = (0, 1, 0, 1))
  854.     g.add(bb, 0, 2, growx = 1)
  855.     rc = g.runOnce()
  856.     return (bb.buttonPressed(rc), l.current())
  857.  
  858.  
  859. def ButtonChoiceWindow(screen, title, text, buttons = [
  860.     'Ok',
  861.     'Cancel'], width = 40, x = None, y = None, help = None):
  862.     """
  863.      - ButtonChoiceWindow(screen, title, text, 
  864.                buttons = [ 'Ok', 'Cancel' ], 
  865.                width = 40, x = None, y = None, help = None):
  866.     """
  867.     bb = ButtonBar(screen, buttons)
  868.     t = TextboxReflowed(width, text, maxHeight = screen.height - 12)
  869.     g = GridFormHelp(screen, title, help, 1, 2)
  870.     g.add(t, 0, 0, padding = (0, 0, 0, 1))
  871.     g.add(bb, 0, 1, growx = 1)
  872.     return bb.buttonPressed(g.runOnce(x, y))
  873.  
  874.  
  875. def EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40, entryWidth = 20, buttons = [
  876.     'Ok',
  877.     'Cancel'], help = None):
  878.     """
  879.     EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
  880.         entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
  881.     """
  882.     bb = ButtonBar(screen, buttons)
  883.     t = TextboxReflowed(width, text)
  884.     count = 0
  885.     for n in prompts:
  886.         count = count + 1
  887.     
  888.     sg = Grid(2, count)
  889.     count = 0
  890.     entryList = []
  891.     for n in prompts:
  892.         if type(n) == types.TupleType:
  893.             (n, e) = n
  894.             e = Entry(entryWidth, e)
  895.         else:
  896.             e = Entry(entryWidth)
  897.         sg.setField(Label(n), 0, count, padding = (0, 0, 1, 0), anchorLeft = 1)
  898.         sg.setField(e, 1, count, anchorLeft = 1)
  899.         count = count + 1
  900.         entryList.append(e)
  901.     
  902.     g = GridFormHelp(screen, title, help, 1, 3)
  903.     g.add(t, 0, 0, padding = (0, 0, 0, 1))
  904.     g.add(sg, 0, 1, padding = (0, 0, 0, 1))
  905.     g.add(bb, 0, 2, growx = 1)
  906.     result = g.runOnce()
  907.     entryValues = []
  908.     count = 0
  909.     for n in prompts:
  910.         entryValues.append(entryList[count].value())
  911.         count = count + 1
  912.     
  913.     return (bb.buttonPressed(result), tuple(entryValues))
  914.  
  915.  
  916. class CListbox(Grid):
  917.     '''Clistbox convenience class.
  918.  
  919.     methods:
  920.  
  921.      - Clistbox(self, height, cols, cols_widths, scroll = 0)       : constructor
  922.      - colFormText(self, col_text, align = None, adjust_width = 0) : column text.
  923.      - append(self, col_text, item, col_text_align = None)         :
  924.      - insert(self, col_text, item, before, col_text_align = None)
  925.      - delete(self, item)
  926.      - replace(self, col_text, item, col_text_align = None)
  927.      - current(self) : returns current item
  928.      - setCurrent(self, item): sets an item as current
  929.      - clear(self): clear the listbox
  930.      
  931.      Alignments may be LEFT, RIGHT, CENTER, None
  932.     '''
  933.     
  934.     def __init__(self, height, cols, col_widths, scroll = 0, returnExit = 0, width = 0, col_pad = 1, col_text_align = None, col_labels = None, col_label_align = None, adjust_width = 0):
  935.         self.cols = cols
  936.         self.col_widths = col_widths[:]
  937.         self.col_pad = col_pad
  938.         self.col_text_align = col_text_align
  939.         if col_labels != None:
  940.             Grid.__init__(self, 1, 2)
  941.             box_y = 1
  942.             lstr = self.colFormText(col_labels, col_label_align, adjust_width = adjust_width)
  943.             self.label = Label(lstr)
  944.             self.setField(self.label, 0, 0, anchorLeft = 1)
  945.         else:
  946.             Grid.__init__(self, 1, 1)
  947.             box_y = 0
  948.         self.listbox = Listbox(height, scroll, returnExit, width)
  949.         self.setField(self.listbox, 0, box_y, anchorRight = 1)
  950.  
  951.     
  952.     def colFormText(self, col_text, align = None, adjust_width = 0):
  953.         i = 0
  954.         str = ''
  955.         c_len = len(col_text)
  956.         while i < self.cols and i < c_len:
  957.             cstr = col_text[i]
  958.             cstrlen = _snack.wstrlen(cstr)
  959.             if self.col_widths[i] < cstrlen:
  960.                 if adjust_width:
  961.                     self.col_widths[i] = cstrlen
  962.                 else:
  963.                     cstr = cstr[:self.col_widths[i]]
  964.             
  965.             delta = self.col_widths[i] - _snack.wstrlen(cstr)
  966.             if delta > 0:
  967.                 if align == None:
  968.                     a = LEFT
  969.                 else:
  970.                     a = align[i]
  971.                 if a == LEFT:
  972.                     cstr = cstr + ' ' * delta
  973.                 
  974.                 if a == CENTER:
  975.                     cstr = ' ' * (delta / 2) + cstr + ' ' * ((delta + 1) / 2)
  976.                 
  977.                 if a == RIGHT:
  978.                     cstr = ' ' * delta + cstr
  979.                 
  980.             
  981.             if i != c_len - 1:
  982.                 pstr = ' ' * self.col_pad
  983.             else:
  984.                 pstr = ''
  985.             str = str + cstr + pstr
  986.             i = i + 1
  987.         return str
  988.  
  989.     
  990.     def append(self, col_text, item, col_text_align = None):
  991.         if col_text_align == None:
  992.             col_text_align = self.col_text_align
  993.         
  994.         text = self.colFormText(col_text, col_text_align)
  995.         self.listbox.append(text, item)
  996.  
  997.     
  998.     def insert(self, col_text, item, before, col_text_align = None):
  999.         if col_text_align == None:
  1000.             col_text_align = self.col_text_align
  1001.         
  1002.         text = self.colFormText(col_text, col_text_align)
  1003.         self.listbox.insert(text, item, before)
  1004.  
  1005.     
  1006.     def delete(self, item):
  1007.         self.listbox.delete(item)
  1008.  
  1009.     
  1010.     def replace(self, col_text, item, col_text_align = None):
  1011.         if col_text_align == None:
  1012.             col_text_align = self.col_text_align
  1013.         
  1014.         text = self.colFormText(col_text, col_text_align)
  1015.         self.listbox.replace(text, item)
  1016.  
  1017.     
  1018.     def current(self):
  1019.         return self.listbox.current()
  1020.  
  1021.     
  1022.     def setCurrent(self, item):
  1023.         self.listbox.setCurrent(item)
  1024.  
  1025.     
  1026.     def clear(self):
  1027.         self.listbox.clear()
  1028.  
  1029.  
  1030.